{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对X1~X4进行标准化处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>X1</th>\n",
       "      <th>X2</th>\n",
       "      <th>X3</th>\n",
       "      <th>X4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.812132</td>\n",
       "      <td>0.057192</td>\n",
       "      <td>-0.857886</td>\n",
       "      <td>1.612825</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-1.234525</td>\n",
       "      <td>0.252215</td>\n",
       "      <td>-0.491155</td>\n",
       "      <td>1.473466</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.666283</td>\n",
       "      <td>1.685303</td>\n",
       "      <td>-0.823055</td>\n",
       "      <td>-0.195965</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.836854</td>\n",
       "      <td>0.426322</td>\n",
       "      <td>-1.026330</td>\n",
       "      <td>1.436862</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.910705</td>\n",
       "      <td>1.431108</td>\n",
       "      <td>-0.962745</td>\n",
       "      <td>0.442343</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         X1        X2        X3        X4\n",
       "0 -0.812132  0.057192 -0.857886  1.612825\n",
       "1 -1.234525  0.252215 -0.491155  1.473466\n",
       "2 -0.666283  1.685303 -0.823055 -0.195965\n",
       "3 -0.836854  0.426322 -1.026330  1.436862\n",
       "4 -0.910705  1.431108 -0.962745  0.442343"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "# 读入基础数据\n",
    "cemht = pd.read_csv(\"http://image.cador.cn/data/cemht.csv\")\n",
    "X = cemht.drop(columns=['No','Y'])\n",
    "y = cemht.Y\n",
    "# 对 X1~X4 进行标准化处理\n",
    "X = X.apply(lambda x: (x - np.mean(x))/np.std(x),axis=1)\n",
    "X.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "计算按原始属性进行交叉验证得到的误差平方和，并存储在变量std_error中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import linear_model \n",
    "\n",
    "def evaluation_regression(X,y):\n",
    "    \"\"\"建立回归问题的评估方法\"\"\"\n",
    "    reg = linear_model.LinearRegression()\n",
    "    errors = 0\n",
    "    for i in range(X.shape[0]):\n",
    "        index = [e for e in range(X.shape[0])]\n",
    "        index.remove(i)\n",
    "        X_train = X.iloc[index,:]\n",
    "        X_test = X.iloc[[i],:]\n",
    "        y_train = y[index]\n",
    "        y_test = y[i]\n",
    "        reg.fit(X_train, y_train)\n",
    "        errors = errors + (y_test - reg.predict(X_test)[0])**2\n",
    "    return errors/np.sum(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16428991916253996"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std_error = evaluation_regression(X,y)\n",
    "std_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "产生初始种群，设种群规模为100，同时设置需要的特征数为3，即个体对应的基因数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_individuals(k, gen_num, input_data, featureIdx, nMax=10):\n",
    "    \"\"\"产生k个个体, gen_num表示每个体对应的固定基因数量\"\"\"\n",
    "    indiv_list = []\n",
    "    gene_list = []\n",
    "    for e in range(k):\n",
    "        indiv = {}\n",
    "        gene = []\n",
    "        for i in range(gen_num):\n",
    "            out = random_get_tree(input_data, featureIdx, nMax) \n",
    "            indiv[\"g\"+str(i+1)]=out['f_value']\n",
    "            gene.append(out['tree_exp'])\n",
    "        indiv = pd.DataFrame(indiv)\n",
    "        indiv_list.append(indiv)\n",
    "        gene_list.append(gene)\n",
    "    return {\"df\":indiv_list, \"gene\": gene_list}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random \n",
    "\n",
    "def random_get_tree(input_data,featureIdx,nMax=10):\n",
    "    \"\"\" \n",
    "    从原始数据特征中，随机获取特征表达树  \n",
    "    featureIdx: 原始特征的下标数值，最小从1开始\n",
    "    nMax:一次最多从特征中可放回抽样次数，默认为10\n",
    "    \"\"\"\n",
    "    data = pd.DataFrame({\"X\"+str(e):input_data.iloc[:,(e-1)].values for e in featureIdx})\n",
    "    \n",
    "    # 随机抽取N个特征下标\n",
    "    N = random.choice(range(2,nMax+1))\n",
    "    \n",
    "    # 随机决定是使用满二叉树还是偏二叉树\n",
    "    if random.choice([0,1]) == 1:\n",
    "        # 选择满二叉树\n",
    "        select_feature_index = [random.choice(featureIdx) for i in range(N)]+[0]*int(2**np.ceil(np.log2(N)) - N)\n",
    "        random.shuffle(select_feature_index)\n",
    "        select_feature_index = ['data.X'+str(e)+\".values\" if e> 0 else '0' for e in select_feature_index]\n",
    "        tree_exp = gen_full_tree_exp(select_feature_index)\n",
    "    else:\n",
    "        # 选择偏二叉树\n",
    "        select_feature_index = ['data.X'+str(e)+\".values\" for e in [random.choice(featureIdx) for i in range(N)]]\n",
    "        tree_exp =  gen_side_tree_exp(select_feature_index)\n",
    "    return {\"f_value\":eval(tree_exp),\"tree_exp\":tree_exp.replace(\"data.\",\"\").replace(\".values\",\"\")}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建满二叉树，并生成数学表达式\n",
    "def gen_full_tree_exp(var_flag_array):\n",
    "    half_n = len(var_flag_array)//2\n",
    "    middle_array = []\n",
    "    for i in range(half_n):\n",
    "        if var_flag_array[i] == '0' and var_flag_array[i+half_n] != '0':\n",
    "            middle_array.append('g('+random.choice(one_group)+','+add_one_group(var_flag_array[i+half_n])+')')\n",
    "        elif var_flag_array[i] != '0' and var_flag_array[i+half_n] == '0':\n",
    "            middle_array.append('g('+random.choice(one_group)+','+add_one_group(var_flag_array[i])+')')\n",
    "        elif var_flag_array[i] != '0' and var_flag_array[i+half_n] != '0':\n",
    "            middle_array.append('g('+random.choice(two_group)+','+add_one_group(var_flag_array[i])+','+add_one_group(var_flag_array[i+half_n])+')')\n",
    "    if len(middle_array) == 1:\n",
    "        return add_one_group(middle_array[0])\n",
    "    else:\n",
    "        return gen_full_tree_exp(middle_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_number = 0.01\n",
    "\n",
    "# 一元运算\n",
    "def log(x):\n",
    "    return np.sign(x)*np.log2(np.abs(x)+1)\n",
    "\n",
    "def sqrt(x):\n",
    "    return np.sqrt(x-np.min(x)+min_number)\n",
    "\n",
    "def pow2(x):\n",
    "    return x**2\n",
    "\n",
    "def pow3(x):\n",
    "    return x**3\n",
    "\n",
    "def inv(x):\n",
    "    return 1*np.sign(x)/(np.abs(x)+min_number)\n",
    "\n",
    "def sigmoid(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return (1 + np.exp(-x))**(-1)\n",
    "\n",
    "def tanh(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return (np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x))\n",
    "\n",
    "def relu(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return np.array([e if e > 0 else 0 for e in x])\n",
    "\n",
    "def binary(x):\n",
    "    if np.std(x) < min_number:\n",
    "        return x\n",
    "    x = (x - np.mean(x))/np.std(x)\n",
    "    return np.array([1 if e > 0 else 0 for e in x])\n",
    "\n",
    "# 二元运算\n",
    "def add(x,y):\n",
    "    return x + y\n",
    "\n",
    "def sub(x,y):\n",
    "    return x - y\n",
    "\n",
    "def times(x,y):\n",
    "    return x * y\n",
    "\n",
    "def div(x,y):\n",
    "    return x*np.sign(y)/(np.abs(y)+min_number)\n",
    "\n",
    "two_group = ['add', 'sub', 'times', 'div']\n",
    "one_group = ['log', 'sqrt', 'pow2', 'pow3', 'inv', 'sigmoid', 'tanh', 'relu', 'binary']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#构建偏二叉树，并生成数学表达式\n",
    "def gen_side_tree_exp(var_flag_array):\n",
    "    if len(var_flag_array) == 1:\n",
    "        return add_one_group(var_flag_array[0])\n",
    "    else:\n",
    "        var_flag_array[1] = 'g('+random.choice(two_group)+','+add_one_group(var_flag_array[0])+','+add_one_group(var_flag_array[1])+')'\n",
    "        del var_flag_array[0]\n",
    "        return gen_side_tree_exp(var_flag_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 随机增加一元运算符\n",
    "def add_one_group(feature_string, prob=0.3):\n",
    "    return 'g('+random.choice(one_group)+','+feature_string+')' if np.random.uniform(0, 1) < prob else feature_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(f, a, b=None):\n",
    "    \"\"\"\n",
    "    f: 一元或二元运算函数\n",
    "    a: 第一个参数\n",
    "    b: 如果f是一元运算函数，则b为空，否则代表二元运算的第二个参数\n",
    "    \"\"\"\n",
    "    if b is None:\n",
    "        return f(a)\n",
    "    else:\n",
    "        return f(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_adjust(std_error, y, indiv_data, handle):\n",
    "    \"\"\"计算适应度，通过外部定义的handle来处理，同时适用于分类和回归问题\"\"\"\n",
    "    X = indiv_data\n",
    "    cur_error = handle(X,y)\n",
    "    return std_error - cur_error if std_error > cur_error else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.02157389, 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.00564825, 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "       0.        , 0.        , 0.        , 0.        , 0.        ])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 产生初始种群，假设种群规模为100\n",
    "popSize = 100\n",
    "# 设置特征长度为3\n",
    "needgs = 3\n",
    "# 交叉重组触发概率\n",
    "cross_prob = 0.85\n",
    "# 突变概率\n",
    "mutate_prob = 0.1\n",
    "# 原始特征序号\n",
    "featureIdx = [1,2,3,4]\n",
    "# 产生初始种群\n",
    "individuals = gen_individuals(popSize,needgs,X,featureIdx)\n",
    "adjusts = []\n",
    "for df in individuals['df']:\n",
    "    adjusts.append(get_adjust(std_error, y, df, evaluation_regression))\n",
    "\n",
    "np.array(adjusts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "设置最大迭代次数为10000，并设置终止条件为种群中最高适应度除以平均适应度的值alpha不超过1.001\n",
    "\n",
    "经过交叉、变异、选择的过程实现了种群的进化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inter_cross(indiv_list, gene_list, prob):\n",
    "    \"\"\" 对染色体进行交叉操作 \"\"\"\n",
    "    gene_num = len(gene_list[0])\n",
    "    ready_index = list(range(len(gene_list)))\n",
    "    while len(ready_index) >= 2:\n",
    "        d1 = random.choice(ready_index)\n",
    "        ready_index.remove(d1)\n",
    "        d2 = random.choice(ready_index)\n",
    "        ready_index.remove(d2)\n",
    "        if np.random.uniform(0, 1) <= prob:\n",
    "            loc = random.choice(range(gene_num))\n",
    "            # print(d1,d2,\"exchange loc --> \",loc)\n",
    "            # 对数据做交叉操作\n",
    "            if indiv_list is not None:\n",
    "                tmp = indiv_list[d1].iloc[:,loc]\n",
    "                indiv_list[d1].iloc[:,loc] = indiv_list[d2].iloc[:,loc]\n",
    "                indiv_list[d2].iloc[:,loc] = tmp\n",
    "                \n",
    "            # 对基因型做交叉操作\n",
    "            tmp = gene_list[d1][loc]\n",
    "            gene_list[d1][loc] = gene_list[d2][loc]\n",
    "            gene_list[d2][loc] = tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutate(indiv_list, gene_list, prob, input_data, featureIdx, nMax=10):\n",
    "    gene_num = len(gene_list[0])\n",
    "    ready_index = list(range(len(gene_list)))\n",
    "    for i in ready_index:\n",
    "        if np.random.uniform(0, 1) <= prob:\n",
    "            loc = random.choice(range(gene_num))\n",
    "            # print(i,\"mutate on --> \",loc)\n",
    "            tmp = random_get_tree(input_data, featureIdx, nMax) \n",
    "            if indiv_list is not None:\n",
    "                indiv_list[i].iloc[:,loc] = tmp['f_value']\n",
    "            gene_list[i][loc] = tmp['tree_exp']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_tree(feature_string, title=None, node_size=5000, font_size=18):\n",
    "    my_dict = transform(feature_string)\n",
    "    root, labels, _ = bitree(my_dict, len(my_dict)-1, 0, labels={})\n",
    "    graph = nx.Graph()\n",
    "    graph, pos = create_graph(graph, root)\n",
    "    nx.draw_networkx(graph, pos, node_size=node_size,width=2,node_color='black',font_color='white',font_size=font_size,with_labels=True,labels=labels)\n",
    "    plt.axis('off')\n",
    "    if title is not None:\n",
    "        plt.title(title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform(feature_string):\n",
    "    my_dict={}\n",
    "    pattern = r'g\\([^\\(\\)]*\\)'\n",
    "    so = re.search(pattern, feature_string)\n",
    "    while so:\n",
    "        start, end = so.span()\n",
    "        key = len(my_dict)\n",
    "        my_dict[key]=so.group()\n",
    "        feature_string = feature_string[0:start]+'<'+str(key)+'>'+feature_string[end:]\n",
    "        so = re.search(pattern, feature_string)\n",
    "    return my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bitree(mapping, start_no, index=0, labels={}):\n",
    "    name, left, right = parse(mapping[start_no])\n",
    "    if left is not None:\n",
    "        if type(left) == int:\n",
    "            left_node, s_labels, max_index = bitree(mapping, left, index+1, labels)\n",
    "            labels = s_labels\n",
    "        else:\n",
    "            left_node = Node(index+1, left)\n",
    "            labels[index+1] = left\n",
    "            max_index = index+1\n",
    "    else:\n",
    "        left_node = None\n",
    "    \n",
    "    if right is not None:\n",
    "        if type(right) == int:\n",
    "            right_node, s_labels, max_index = bitree(mapping, right, max_index+1, labels)\n",
    "            labels = s_labels\n",
    "        else:\n",
    "            right_node = Node(max_index+1, right)\n",
    "            labels[max_index+1] = right\n",
    "            max_index = max_index+1\n",
    "    else:\n",
    "        right_node = None\n",
    "        \n",
    "    labels[index] = name\n",
    "    return Node(index, name, left_node, right_node) ,labels, max_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse(group_unit):\n",
    "    tmp = group_unit.lstrip(\"g(\").rstrip(\")\").split(',')\n",
    "    tmp = tmp + [None] if len(tmp) == 2 else tmp\n",
    "    return [int(x[1:-1]) if x is not None and re.match(r'<[0-9]+>',x) else x for x in tmp]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self, value, label, left=None, right=None):\n",
    "        self.value = value\n",
    "        self.label = label\n",
    "        self.left = left  \n",
    "        self.right = right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_graph(G, node, pos={}, x=0, y=0, layer=1):\n",
    "    pos[node.value] = (x, y)\n",
    "    if node.left:\n",
    "        G.add_edge(node.value, node.left.value)\n",
    "        l_x, l_y = x - 1 / layer, y - 1\n",
    "        l_layer = layer + 1\n",
    "        create_graph(G, node.left, x=l_x, y=l_y, pos=pos, layer=l_layer)\n",
    "    if node.right:\n",
    "        G.add_edge(node.value, node.right.value)\n",
    "        r_x, r_y = x + 1 / layer, y - 1\n",
    "        r_layer = layer + 1\n",
    "        create_graph(G, node.right, x=r_x, y=r_y, pos=pos, layer=r_layer)\n",
    "    return G, pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第  1  次迭代，最大适应度为  0.08591943708847169  alpha :  37.81021616783306\n",
      "第  100  次迭代，最大适应度为  0.12333812064289865  alpha :  1.3115517283838802\n",
      "第  200  次迭代，最大适应度为  0.12418995555475974  alpha :  1.3893638634377674\n",
      "第  300  次迭代，最大适应度为  0.12480782837384688  alpha :  1.4516179127953797\n",
      "第  400  次迭代，最大适应度为  0.13006510536785792  alpha :  1.5565837346093536\n",
      "第  500  次迭代，最大适应度为  0.130065105367858  alpha :  1.4844009330007006\n",
      "第  600  次迭代，最大适应度为  0.13110915834456696  alpha :  1.3223697070277847\n",
      "第  700  次迭代，最大适应度为  0.131109158344567  alpha :  1.4222408661981065\n",
      "第  800  次迭代，最大适应度为  0.131109158344567  alpha :  1.4256047991453666\n",
      "第  900  次迭代，最大适应度为  0.13417166430488986  alpha :  1.442265551336159\n",
      "第  1000  次迭代，最大适应度为  0.1341716643048899  alpha :  1.534241439151955\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "max_epochs = 1000\n",
    "for k in range(max_epochs):\n",
    "    # 0.备份父代个体\n",
    "    pre_indivs = copy.deepcopy(individuals)\n",
    "    pre_adjusts = adjusts.copy()\n",
    "    # 1.交叉\n",
    "    inter_cross(individuals['df'], individuals['gene'], cross_prob)\n",
    "    # 2.变异\n",
    "    mutate(individuals['df'], individuals['gene'], mutate_prob, X, featureIdx)\n",
    "    # 3.计算适应度\n",
    "    adjusts = []\n",
    "    for df in individuals['df']:\n",
    "        adjusts.append(get_adjust(std_error, y, df, evaluation_regression))\n",
    "\n",
    "    # 4.合并，并按adjusts降序排列，取前0.4*popSize个个体进行返回，对剩余的个体随机选取0.6*popSize个返回\n",
    "    pre_gene_keys = [''.join(e) for e in pre_indivs['gene']]\n",
    "    gene_keys = [''.join(e) for e in individuals['gene']]\n",
    "    for i in range(len(pre_gene_keys)):\n",
    "        key = pre_gene_keys[i]\n",
    "        if key not in gene_keys:\n",
    "            individuals['df'].append(pre_indivs['df'][i])\n",
    "            individuals['gene'].append(pre_indivs['gene'][i])\n",
    "            adjusts.append(pre_adjusts[i])\n",
    "\n",
    "    split_val = pd.Series(adjusts).quantile(q=0.6)\n",
    "    index = list(range(len(adjusts)))\n",
    "    need_delete_count = len(adjusts) - popSize\n",
    "    random.shuffle(index)\n",
    "    indices  = []\n",
    "    for i in index:\n",
    "        if need_delete_count > 0:\n",
    "            if adjusts[i] <= split_val:\n",
    "                indices.append(i)\n",
    "                need_delete_count = need_delete_count -1\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    individuals['df'] = [i for j, i in enumerate(individuals['df']) if j not in indices]\n",
    "    individuals['gene'] = [i for j, i in enumerate(individuals['gene']) if j not in indices]\n",
    "    adjusts = [i for j, i in enumerate(adjusts) if j not in indices]\n",
    "    alpha = np.max(adjusts)/np.mean(adjusts)\n",
    "    if k%100 == 99 or k==0:\n",
    "        print(\"第 \",k+1,\" 次迭代，最大适应度为 \",np.max(adjusts),\" alpha : \",alpha)\n",
    "    if np.mean(adjusts) > 0 and alpha < 1.001:\n",
    "        print(\"进化终止，算法已收敛！ 共进化 \",k,\" 代！\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "提取最佳特征组合，构建新数据集，同时绘制出各特征表达式的二叉树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>g1</th>\n",
       "      <th>g2</th>\n",
       "      <th>g3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.273897</td>\n",
       "      <td>0.811421</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.146156</td>\n",
       "      <td>0.987183</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.787916</td>\n",
       "      <td>-1.013655</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.260843</td>\n",
       "      <td>0.496239</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.271575</td>\n",
       "      <td>-0.604454</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         g1        g2  g3\n",
       "0 -0.273897  0.811421   1\n",
       "1 -0.146156  0.987183   1\n",
       "2 -0.787916 -1.013655   0\n",
       "3 -0.260843  0.496239   1\n",
       "4 -0.271575 -0.604454   0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#提取适应度最高的一个个体，获取其特征\n",
    "loc = np.argmax(adjusts)\n",
    "new_x = individuals['df'][loc]\n",
    "new_x.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x1440 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "import matplotlib\n",
    "import re\n",
    "# 以下 font.family 设置仅适用于 Mac系统，其它系统请使用对应字体名称\n",
    "matplotlib.rcParams['font.family'] = 'Arial Unicode MS'\n",
    "counter = 1\n",
    "titles=['特征-g1','特征-g2','特征-g3']\n",
    "plt.figure(figsize=(10,20))\n",
    "for e in individuals['gene'][loc]:\n",
    "    plt.subplot(3,1,counter)\n",
    "    plot_tree(e, title=titles[counter - 1],node_size= 1000,font_size=13)\n",
    "    counter = counter + 1\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
